Depth Complexity in Object-Parallel Graphics Architectures

We consider a multiprocessor graphics architecture object-parallel if graphics primitives are assigned to processors without regard to screen location, and if each processor completely renders the primitives it is assigned. Such an approach leads to the following problem: the images rendered by all processors must be merged, or composited, before they can be displayed. At worst, the number of pixels that must be merged is a frame per processor. Perhaps there is a more parsimonious approach to pixel merging in object-parallel architectures than merging a full frame from each processor. In this paper we analyze the number of pixels that must be merged in object-parallel architectures. Our analysis is from the perspective that the number of pixels to be merged is a function of the depth complexity of the graphics scene to be rendered, and a function of the depth complexity of each processor's subset of the scene to be rendered. We derive a model of depth complexity of graphics scenes rendered on object-parallel architectures. The model is based strictly on the graphics primitive size distribution, and on number of processors. \Ve validate the model with trace data from a number of graphics applications, and with trace-driven simulations of rendering on object-parallel architectures. The results of our analysis suggest some directions in design of object-parallel architectures, and suggest that our model can be used in future analysis of design trade-offs in these architectures.